﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<vector>
using namespace std;

//class BirthDay
//{
//public:
//	BirthDay(int y=1949, int m=10, int d=1)
//		:_year(y)
//		,_month(m)
//		,_day(d)
//	{
//		cout << "BirthDay(int y=1949, int m=10, int d=1)--默认构造" << endl;
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//	BirthDay(const BirthDay& birday)
//		:_year(birday._year)
//		, _month(birday._month)
//		, _day(birday._day)
//	{
//		cout << "BirthDay(const BirthDay& birday)--拷贝构造" << endl;
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	BirthDay a={ 2024,10,27 };
//	const BirthDay& b = { 2014,10,27 };
//	BirthDay a1{ 2025,10,27 };
//	const BirthDay& b1 = { 2015,10,27 };
//
//	vector<BirthDay> vb;
//	vb.push_back({ 2015,10,25 });
//
//	vector<string> vs;
//	vs.push_back({ "one last kiss" });
//
//	initializer_list<int> il = { 1,2,3 };
//	cout << typeid(il).name() << endl;
//
//	vector<int> arr = { 1,2,3,4,5 };//这里是initializer_list对容器进行初始化
//	arr.push_back({ 6 });//这里是列表初始化
//
//	vector<int> v1({ 1,2,3,4,5 });//直接构造
//	vector<int> v2 = { 1,2,3,4,5 };//临时对象构造，临时对象拷贝构造给v2---这一过程编译器优化成直接构造
//
//	cout << endl;
//	/*vector<string> vstr;
//	vstr.push_back("123");
//	vstr.push_back("234");*/
//
//	/*vector<BirthDay> bir;
//	cout << "=========================================================" << endl;
//	BirthDay tem = { 2024,10,27 };
//	bir.push_back(tem);
//	cout << "---------------------------------------------------------" << endl;
//	bir.push_back(BirthDay{ 2000,10,27 });
//	cout << "---------------------------------------------------------" << endl;
//	bir.push_back({ 2023,10,23 });
//	cout << "---------------------------------------------------------" << endl;
//	bir.push_back({ 2023,10,23 });
//	cout << "=========================================================" << endl;*/
//	return 0;
//}

//
//#include<utility>
//int main()
//{
//	//p a b *p s s[0]皆为左值
//	int* p = new int(0);
//	int a = 1;
//	const int b = a;
//	*p = 10;
//	string s("12345");
//	s[0] = 'x';
//
//	//它们都能取地址
//	cout << &p << endl;
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &(*p) << endl;
//	cout << &s << endl;
//	cout << (void*)&s[0] << endl;
//
//	//左值引用
//	int*& rp = p;
//	int& ra = a;
//	const int& rb = b;
//	int& rpp = *p;
//	string& ps = s;
//	char& ps0 = s[0];
//
//	//右值引用
//	int c = 1;
//	//int&& ra = c;//-----编译器报错
//	int&& rc = move(c);
//
//	cout << endl;
//}

//int Add(int a, int b)
//{
//	return a + b;
//}
//
//int main()
//{
//	double x = 1.1, y = 2.2;
//
//	//以下皆为右值
//	/*
//	10;
//	x + y;
//	Add(1, 2);
//	string("123");
//	*/
//
//	//不能对右值进行取地址
//	/*cout << &10 << endl;
//	cout << &(x + y) << endl;
//	cout << &(Add(1, 2)) << endl;
//	cout << &string("123") << endl;*/
//
//	int&& r10 = 10;
//	double&& rxy = (x + y);
//	int&& radd = Add(1, 2);
//	string&& rstr = string("123");
//
//	r10++;
//	cout << "r10的地址为：" << &r10 << endl;
//	cout << "r10的值为：" << r10 << endl;
//	return 0;
//}

//#include <iostream>
//#include <vector>
//using namespace std;
//
//int GetMax(vector<int>& ar, int x)//重排字符串
//{
//    int max = 0;
//    int maxi = 0;
//    for (int i = 0; i < ar.size(); i++)
//    {
//        if (ar[i] > max && x != i)
//        {
//            max = ar[i];
//            maxi = i;
//        }
//    }
//    if (max == 0)
//        return -1;
//    else
//        return maxi;
//}
//
//int main() {
//    int n;
//    vector<int> arr(26);
//    cin >> n;
//    string str;
//    int y = n;
//    cin >> str;
//    for (char i : str)
//    {
//        arr[i - 'a']++;
//    }
//    str.erase(0, str.npos);
//    int i = GetMax(arr, -1);
//    while (i != -1)
//    {
//        str.push_back(i + 'a');
//        arr[i]--;
//        i = GetMax(arr, i);
//    }
//    if (str.size() != y)
//        cout << "no";
//    else
//    {
//        cout << "yes" << endl;
//        cout << str << endl;
//    };
//}
//// 64 位输出请用 printf("%lld")
//
//
//
//
//
//
//
////最长无重复子数组
//class Solution {
//public:
//    /**
//     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
//     *
//     *
//     * @param arr int整型vector the array
//     * @return int整型
//     */
//    int maxLength(vector<int>& arr) {
//        if (arr.size() <= 1)
//            return arr.size();
//        // write code here
//        int len = 0;
//        int count[100001] = { 0 };
//        for (int left = 0, right = 0; right < arr.size(); right++)
//        {
//            count[arr[right]]++;
//            while (count[arr[right]] > 1)
//            {
//                count[arr[left++]]--;
//            }
//            len = max(len, right - left + 1);
//        }
//        return len;
//    }
//};
//
//
//
//
////牛牛冲钻石
//#include <iostream>
//#include <string>
//using namespace std;
//
//int main() {
//    int n, a, b;
//    string str;
//    cin >> n;
//    while (n--)
//    {
//        long long int score = 0;
//        long long int win = 0;
//        cin >> a >> b >> str;
//        for (int i = 0; i < a; i++)
//        {
//            char ch = str[i];
//            if (ch == 'W')
//            {
//                win++;
//                if (win >= 3)
//                    score += b;
//                else
//                    score++;
//            }
//            else {
//                win = 0;
//                score--;
//            }
//        }
//        cout << score << endl;
//    }
//}

//struct A
//{
//	A(int a)
//		:_a(a)
//	{
//		cout<<_a << "构造函数" << endl;
//	}
//
//	~A()
//	{
//		cout<<_a << "析构函数" << endl;
//	}
//	
//	int _a;
//};
//
//int main()
//{
//	A a(2);
//	//A&& rA=A(1);//匿名对象--生命周期只在当前行
//	const A& rA = A(1);
//	cout << "-------------------------------------------" << endl;
//	cout << "-------------------------------------------" << endl;
//	cout << "-------------------------------------------" << endl;
//	cout << "-------------------------------------------" << endl;
//	cout << "-------------------------------------------" << endl;
//	return 0;
//}

//class Solution {
//public:
//	vector<vector<int>> generate(int numRows) {
//		vector<vector<int>> vv(numRows);
//		for (int i = 0; i < numRows; ++i)
//		{
//			vv[i].resize(i + 1, 1);
//		}
//		for (int i = 2; i < numRows; ++i)
//		{
//			for (int j = 1; j < i; ++j)
//			{
//				vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
//			}
//		}
//		return vv;
//	}
//};
//
//int main()
//{
//	Solution s;
//
//	vector<vector<int>> arr = s.generate(4);
//	return 0;
//}




//namespace ly
//{
//	struct String
//	{
//		//...
//		// 这里省略String类的具体模拟实现
//		//....
//
//		//省略具体模拟实现
//		String(const char* str="")
//		{
//
//		}
//
//		String(String& st)
//		{
//
//		}
//		String* operator=(const String& st)
//		{
//
//		}
//
//		void operator+=(char ch)
//		{
//
//		}
//
//		char operator[](int a)
//		{
//			return 'a';
//		}
//
//		int begin()
//		{
//			//....
//			return 1;
//		}
//
//		int end()
//		{
//			//...
//			return 1;
//		}
//
//		int size()
//		{
//			return _size;
//		}
//
//
//
//		void Swap(String& y)
//		{
//			std::swap(_size, y._size);
//			std::swap(_capacity, y._capacity);
//			std::swap(_arr, y._arr);
//		}
//
//		//移动构造
//		String(String&& temp)//temp可以为临时对象或者匿名对象
//		{
//			Swap(temp);
//		}
//
//		String& operator=(String&& temp)
//		{
//			Swap(temp);
//			return *this;
//		}
//
//	public:
//		int _size;
//		int _capacity;
//		int* _arr;
//
//	};
//
//	String addStrings(String num1, String num2)
//	{
//		String str;
//		int end1 = num1.size() - 1, end2 = num2.size() - 1;
//		int next = 0;
//		while (end1 >= 0 || end2 >= 0)
//		{
//			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//			int ret = val1 + val2 + next;
//			next = ret / 10;
//			ret = ret % 10;
//			str += ('0' + ret);
//		}
//			if (next == 1)
//				str += '1';
//		reverse(str.begin(), str.end());
//		cout << "******************************" << endl;
//		return str;
//	}
//}
//
//int main()
//{
//	//ly::String ret = ly::addStrings("11111", "2222");
//	ly::String ret;
//	ret= ly::addStrings("11111", "2222");
//	return 0;
//}

//int main()
//{
//	typedef int& lf;
//	typedef int&& rf;
//	int n = 0;
//
//	lf& r1 = n;//r1：左值引用的左值引用----左值引用
//	lf&& r2 = n;//r2：左值引用的右值引用----左值引用
//
//	rf& r3 = n;//r3：右值引用的左值引用----左值引用
//	rf&& r4 = move(n);//r4：右值引用的右值引用---右值引用
//
//	return 0;
//}

//template<class T>
//void f1(T& x)
//{
//
//}
//
//int main()
//{
//	int n = 0;
//
//	//没有发生折叠--实例化为void f1(int& x)
//	f1<int>(n);
//	f1<int>(0);//编译器报错，实例化为void f1(int& 0),左值引用不能引用右值
//
//	//发生了折叠--左值引用的左值引用--实例化为void f1(int& x)
//	f1<int&>(n);
//	f1<int&>(0);//编译器报错，实例化为void f1(int& 0),左值引用不能引用右值
//
//	//发生了折叠--右值引用的左值引用--实例化为void f1(int& x)
//	f1<int&&>(n);
//	f1<int&&>(0);//编译器报错，实例化为void f1(int& 0),左值引用不能引用右值
//
//	//发生了折叠--左值引用的左值引用--实例化为void f1(const int& x)
//	f1<const int&>(n);
//	f1<const int&>(0);//编译器不报错，因为const 左值引用可以绑定右值
//
//	//发生了折叠--右值引用的左值引用--实例化为void f1(const int& x)
//	f1<const int&&>(n);
//	f1<const int&&>(0);//编译器不报错，因为const 左值引用可以绑定右值
//
//	return 0;
//}

//template<class T>
//void f2(T&& x)
//{
//
//}
//
//int main()
//{
//
//	int n = 0;
//
//	//没有发生折叠--实例化为void f2(int&& x)
//	f2<int>(n);//编译器报错，实例化为void f2(int&& n),右值引用不能引用左值
//	f2<int>(0);
//
//	//发生了折叠--右值引用的左值引用--实例化为void f2(int& x)
//	f2<int&>(n);
//	f2<int&>(0);//编译器报错，实例化为void f2(int& 0),左值引用不能引用右值
//
//	//发生了折叠--右值引用的右值引用--实例化为void f2(int&& x)
//	f2<int&&>(n);//编译器报错，实例化为void f2(int&& x),右值引用不能引用左值
//	f2<int&&>(0);
//
//	//发生了折叠--右值引用的左值引用--实例化为void f2(const int& x)
//	f2<const int&>(n);
//	f2<const int&>(0);//编译器不报错，因为const 左值引用可以绑定右值
//
//	//发生了折叠--右值引用的右值引用--实例化为void f2(const int&& x)
//	f2<const int&&>(n);//编译器报错，实例化为void f2(const int&& n),const 右值引用不能引用左值
//	f2<const int&&>(0);
//
//	return 0;
//}


//template<class T>
//void Func(T&& t)
//{
//	int a = 10;
//	T x = a;
//	x++;
//	cout << &a << endl;
//	cout << &x << endl;
//}
//
//int main()
//{
//	int b;
//
//	//Func(10);//右值，T推导为int
//
//	//Func(b);//左值，T推导为int&
//
//	//Func(move(b));//右值，T推导为int
//
//	const int cb=1;
//	//Func(cb);//const左值，T被推导为const int&，不能修改但是可以求地址
//
//	Func(move(cb));
//
//	return 0;
//}

//void Fun(int& x) { cout <<x<< "左值引用" << endl; }
//void Fun(const int& x) { cout<<x << "const 左值引用" << endl; }
//void Fun(int&& x) { cout<<x << "右值引用" << endl; }
//void Fun(const int&& x) { cout<<x << "const 右值引用" << endl; }
//
//template<class T>
//void Function(T&& t)
//{
//	Fun(t);
//}
//
//int main()
//{
//	Function(1);//在Function函数中实例化为右值引用，T为int，即int&&
//
//	int a = 2;
//	Function(a);//在Function函数中实例化为左值引用，T为int&，即int&
//
//	a++;
//	int& b = a;
//	Function(b);//在Function函数中实例化为左值引用，T为int&，即int&
//
//	int&& c = 4;
//	Function(c);//在Function函数中实例化为右值引用，T为int&&，即int&&
//
//	a+=2;
//	const int& d = a;
//	Function(d);//在Function函数中实例化为左值引用，T为const int&，即const int&
//
//	const int&& e = 6;
//	Function(6);//在Function函数中实例化为右值引用，T为const int&&，即const int&&
//
//	return 0;
//}



//int main()
//{
//	int&& ra = 1;
//	cout << ++ra << " " << &ra << endl;
//	return 0;
//}

#include<utility>

void Fun(int& x) { cout <<x<< "左值引用" << endl; }
void Fun(const int& x) { cout<<x << "const 左值引用" << endl; }
void Fun(int&& x) { cout<<x << "右值引用" << endl; }
void Fun(const int&& x) { cout<<x << "const 右值引用" << endl; }

template<class T>
void Function(T&& t)
{
	Fun(forward<T>(t));
}

int main()
{
	Function(1);//在Function函数中实例化为右值引用，T为int，即int&&

	int a = 2;
	Function(a);//在Function函数中实例化为左值引用，T为int&，即int&

	a++;
	int& b = a;
	Function(b);//在Function函数中实例化为左值引用，T为int&，即int&

	int&& c = 4;
	Function(move(c));//在Function函数中实例化为右值引用，T为int&&，即int&&

	a+=2;
	const int& d = a;
	Function(d);//在Function函数中实例化为左值引用，T为const int&，即const int&

	const int&& e = 6;
	Function(move(e));//在Function函数中实例化为右值引用，T为const int&&，即const int&&

	return 0;
}

